/**
 * 地理编码工具函数
 * 提供经纬度与地址之间的转换功能
 */

// 高德地图 Web API Key（需要申请）
// 注意：这里需要替换为您的真实API Key
const AMAP_WEB_API_KEY = 'your_amap_web_api_key_here'

// 临时解决方案：使用内置的城市坐标映射
const COORDINATE_ADDRESS_MAP: Record<string, string> = {
  // 您日志中的具体坐标
  '113.332451,23.13412': '广东省广州市天河区珠江新城',
  '105.550667,29.310204': '重庆市渝中区解放碑',
  '112.493631,23.081714': '广东省佛山市禅城区祖庙',
  '116.995900,26.811509': '福建省莆田市城厢区',
  
  // 常用测试坐标
  '116.397400,39.909300': '北京市东城区天安门广场',
  '121.490700,31.240800': '上海市黄浦区外滩',
  '114.057900,22.543100': '广东省深圳市福田区平安大厦',
  '120.155100,30.274100': '浙江省杭州市西湖区西湖'
}

/**
 * 逆地理编码：将经纬度转换为地址
 * @param lng 经度
 * @param lat 纬度
 * @returns Promise<string> 地址字符串
 */
export async function reverseGeocode(lng: number, lat: number): Promise<string> {
  try {
    // 检查坐标有效性
    if (!lng || !lat || isNaN(lng) || isNaN(lat)) {
      throw new Error('无效的坐标参数')
    }

    console.log('开始逆地理编码:', { lng, lat })

    // 首先尝试从内置映射中查找
    const coordKey = `${lng},${lat}`
    if (COORDINATE_ADDRESS_MAP[coordKey]) {
      console.log('从内置映射获取地址:', COORDINATE_ADDRESS_MAP[coordKey])
      return COORDINATE_ADDRESS_MAP[coordKey]
    }

    // 如果已经加载了高德地图JS API，优先使用（您的API已配置正确）
    if (window.AMap && window.AMap.Geocoder) {
      console.log('使用高德地图JS API进行逆地理编码')
      try {
        const address = await reverseGeocodeWithJSAPI(lng, lat)
        return address
      } catch (jsApiError) {
        console.warn('JS API调用失败，尝试Web API:', jsApiError)
        // 如果JS API失败，继续尝试Web API
      }
    }

    // 检查API Key是否已配置，使用Web API作为备选
    if (AMAP_WEB_API_KEY !== 'your_amap_web_api_key_here') {
      console.log('使用高德地图Web API进行逆地理编码')
      return await reverseGeocodeWithWebAPI(lng, lat)
    }

    // 最后的降级方案
    console.warn('所有API调用失败，使用粗略位置判断')
    throw new Error('API调用失败')
  } catch (error) {
    console.error('逆地理编码失败:', error)
    // 降级到粗略位置判断
    return getApproximateLocation(lng, lat)
  }
}

/**
 * 粗略的地理位置判断（基于坐标范围）
 */
function getApproximateLocation(lng: number, lat: number): string {
  // 中国主要城市的粗略坐标范围
  const cityRanges = [
    { name: '北京市', lngRange: [115.7, 117.4], latRange: [39.4, 41.6] },
    { name: '上海市', lngRange: [120.9, 121.9], latRange: [30.7, 31.9] },
    { name: '广州市', lngRange: [113.0, 113.8], latRange: [22.8, 23.6] },
    { name: '深圳市', lngRange: [113.7, 114.6], latRange: [22.4, 22.9] },
    { name: '重庆市', lngRange: [105.0, 110.0], latRange: [28.0, 32.0] },
    { name: '天津市', lngRange: [116.8, 118.0], latRange: [38.8, 40.3] },
    { name: '杭州市', lngRange: [119.7, 120.4], latRange: [29.9, 30.6] },
    { name: '南京市', lngRange: [118.4, 119.2], latRange: [31.9, 32.4] },
    { name: '武汉市', lngRange: [113.8, 114.8], latRange: [30.1, 31.0] },
    { name: '成都市', lngRange: [103.6, 104.5], latRange: [30.2, 31.0] },
    { name: '西安市', lngRange: [108.6, 109.2], latRange: [34.0, 34.6] },
    { name: '苏州市', lngRange: [120.2, 121.0], latRange: [31.1, 31.7] },
    { name: '佛山市', lngRange: [112.8, 113.4], latRange: [22.8, 23.4] },
    { name: '莆田市', lngRange: [118.8, 119.2], latRange: [25.2, 25.6] },
    { name: '福州市', lngRange: [119.0, 119.6], latRange: [25.9, 26.3] }
  ]
  
  // 查找匹配的城市
  for (const city of cityRanges) {
    if (lng >= city.lngRange[0] && lng <= city.lngRange[1] && 
        lat >= city.latRange[0] && lat <= city.latRange[1]) {
      return `${city.name}附近`
    }
  }
  
  // 粗略的省份判断
  if (lng >= 113 && lng <= 115 && lat >= 22 && lat <= 25) {
    return '广东省'
  } else if (lng >= 105 && lng <= 110 && lat >= 28 && lat <= 32) {
    return '重庆市'
  } else if (lng >= 118 && lng <= 120 && lat >= 25 && lat <= 27) {
    return '福建省'
  } else if (lng >= 115 && lng <= 118 && lat >= 39 && lat <= 41) {
    return '北京市'
  } else if (lng >= 120 && lng <= 122 && lat >= 30 && lat <= 32) {
    return '上海市'
  }
  
  // 如果都不匹配，返回坐标
  return `位置: ${lng.toFixed(6)}, ${lat.toFixed(6)}`
}

/**
 * 使用高德地图JS API进行逆地理编码
 */
async function reverseGeocodeWithJSAPI(lng: number, lat: number): Promise<string> {
  return new Promise((resolve, reject) => {
    const geocoder = new window.AMap.Geocoder({
      radius: 1000,
      extensions: 'all'
    })

    const lnglat = new window.AMap.LngLat(lng, lat)
    
    geocoder.getAddress(lnglat, (status: string, result: any) => {
      console.log('高德地图逆地理编码详细结果:', {
        status,
        result,
        info: result?.info,
        regeocode: result?.regeocode,
        formattedAddress: result?.regeocode?.formattedAddress,
        addressComponent: result?.regeocode?.addressComponent
      })
      
      if (status === 'complete' && result.info === 'OK') {
        const regeocode = result.regeocode
        let address = ''
        
        // 优先使用格式化地址
        if (regeocode && regeocode.formattedAddress) {
          address = regeocode.formattedAddress
          console.log('使用格式化地址:', address)
        } 
        // 如果没有格式化地址，尝试手动拼接
        else if (regeocode && regeocode.addressComponent) {
          const addr = regeocode.addressComponent
          console.log('地址组件:', addr)
          
          // 简化拼接逻辑，确保获取完整地址
          const parts = [
            addr.province || '',
            addr.city || '',
            addr.district || '',
            addr.township || '',
            addr.street || '',
            addr.streetNumber || ''
          ].filter(part => part && part.trim() !== '')
          
          address = parts.join('')
          console.log('手动拼接地址:', address, '组件:', parts)
        }
        
        // 降低地址验证要求
        if (address && address.trim() !== '') {
          console.log('成功获取地址:', address)
          resolve(address)
        } else {
          console.warn('获取到空地址，result:', result)
          reject(new Error('获取到空地址'))
        }
      } else {
        console.error('JS API逆地理编码失败:', { 
          status, 
          info: result?.info, 
          fullResult: result 
        })
        reject(new Error(`JS API逆地理编码失败: ${status} - ${result?.info || '未知错误'}`))
      }
    })
  })
}

/**
 * 使用高德地图Web API进行逆地理编码
 */
async function reverseGeocodeWithWebAPI(lng: number, lat: number): Promise<string> {
  const url = `https://restapi.amap.com/v3/geocode/regeo`
  const params = new URLSearchParams({
    key: AMAP_WEB_API_KEY,
    location: `${lng},${lat}`,
    poitype: '',
    radius: '1000',
    extensions: 'all',
    batch: 'false',
    roadlevel: '0'
  })

  const response = await fetch(`${url}?${params}`)
  const data = await response.json()

  if (data.status === '1' && data.regeocode) {
    return data.regeocode.formatted_address || '未知地址'
  } else {
    throw new Error(`Web API逆地理编码失败: ${data.info}`)
  }
}

/**
 * 批量逆地理编码
 * @param coordinates 坐标数组 [[lng, lat], ...]
 * @returns Promise<string[]> 地址数组
 */
export async function batchReverseGeocode(coordinates: [number, number][]): Promise<string[]> {
  const results: string[] = []
  
  // 限制并发数量，避免API调用过频繁
  const batchSize = 5
  for (let i = 0; i < coordinates.length; i += batchSize) {
    const batch = coordinates.slice(i, i + batchSize)
    const batchPromises = batch.map(([lng, lat]) => reverseGeocode(lng, lat))
    const batchResults = await Promise.all(batchPromises)
    results.push(...batchResults)
    
    // 添加延迟，避免API频率限制
    if (i + batchSize < coordinates.length) {
      await new Promise(resolve => setTimeout(resolve, 100))
    }
  }
  
  return results
}

/**
 * 正地理编码：将地址转换为经纬度
 * @param address 地址字符串
 * @returns Promise<[number, number] | null> [经度, 纬度] 或 null
 */
export async function geocode(address: string): Promise<[number, number] | null> {
  try {
    if (!address || address.trim() === '') {
      throw new Error('地址不能为空')
    }

    // 优先使用JS API
    if (window.AMap && window.AMap.Geocoder) {
      return await geocodeWithJSAPI(address)
    }

    // 否则使用Web API
    return await geocodeWithWebAPI(address)
  } catch (error) {
    console.error('地理编码失败:', error)
    return null
  }
}

/**
 * 使用高德地图JS API进行地理编码
 */
async function geocodeWithJSAPI(address: string): Promise<[number, number] | null> {
  return new Promise((resolve, reject) => {
    const geocoder = new window.AMap.Geocoder({
      extensions: 'all'
    })

    geocoder.getLocation(address, (status: string, result: any) => {
      if (status === 'complete' && result.info === 'OK') {
        const geocodes = result.geocodes
        if (geocodes && geocodes.length > 0) {
          const location = geocodes[0].location
          resolve([location.lng, location.lat])
        } else {
          resolve(null)
        }
      } else {
        reject(new Error('JS API地理编码失败'))
      }
    })
  })
}

/**
 * 使用高德地图Web API进行地理编码
 */
async function geocodeWithWebAPI(address: string): Promise<[number, number] | null> {
  const url = `https://restapi.amap.com/v3/geocode/geo`
  const params = new URLSearchParams({
    key: AMAP_WEB_API_KEY,
    address: address,
    batch: 'false'
  })

  const response = await fetch(`${url}?${params}`)
  const data = await response.json()

  if (data.status === '1' && data.geocodes && data.geocodes.length > 0) {
    const location = data.geocodes[0].location.split(',')
    return [parseFloat(location[0]), parseFloat(location[1])]
  } else {
    return null
  }
}

/**
 * 格式化坐标显示
 * @param lng 经度
 * @param lat 纬度
 * @param precision 精度，默认6位小数
 * @returns 格式化后的坐标字符串
 */
export function formatCoordinates(lng: number, lat: number, precision: number = 6): string {
  return `${lng.toFixed(precision)}, ${lat.toFixed(precision)}`
}

/**
 * 检查坐标是否在中国境内（粗略检查）
 * @param lng 经度
 * @param lat 纬度
 * @returns boolean
 */
export function isInChina(lng: number, lat: number): boolean {
  // 中国大陆的粗略边界
  return lng >= 73 && lng <= 135 && lat >= 3 && lat <= 54
}

// 城市坐标库（用于快速查找常见城市）
export const CITY_COORDINATES: Record<string, [number, number]> = {
  '北京': [116.4074, 39.9042],
  '上海': [121.4737, 31.2304],
  '广州': [113.2644, 23.1291],
  '深圳': [114.0579, 22.5431],
  '杭州': [120.1551, 30.2741],
  '南京': [118.7969, 32.0603],
  '武汉': [114.3054, 30.5931],
  '成都': [104.0665, 30.5723],
  '西安': [108.9398, 34.3416],
  '重庆': [106.5516, 29.5630],
  '天津': [117.2008, 39.0842],
  '苏州': [120.6519, 31.3989],
  '长沙': [112.9388, 28.2282],
  '郑州': [113.6254, 34.7466],
  '青岛': [120.3826, 36.0986],
  '大连': [121.6147, 38.9140],
  '宁波': [121.5440, 29.8683],
  '厦门': [118.1689, 24.4799],
  '福州': [119.3063, 26.0745],
  '济南': [117.0009, 36.6758]
}

/**
 * 根据地址获取推荐坐标（优先使用城市坐标库）
 * @param address 地址字符串
 * @returns [number, number] | null
 */
export function getCoordinatesByAddress(address: string): [number, number] | null {
  // 在城市坐标库中查找
  for (const [city, coords] of Object.entries(CITY_COORDINATES)) {
    if (address.includes(city)) {
      return coords
    }
  }
  return null
}